# def adc():
#     return adc()
#     # 递归错误：超过了最大递归深度
#     # 在函数体内要设置一个出口  当我的某个条件满足时我才退出我的函数体
# adc()

# for i in range(1,10000):
#     print(i)
#     if i == 1000:   # 出口
#         break

# def fun1():
#     print('自戒')
#
#
# def fun2():
#     print('用户7413')
#     # 在函数体中又有一个完整的函数体
#     fun1()  # 函数的嵌套调用
#     def fun3():
#         print('我是帅哥！！！') # 函数的嵌套
#
# fun2()

# 用正向递推的方式计算阶乘
"""
5的阶乘   5!
5！ = 5*4*3*2*1
"""
def factorial(n):  # n = 5
    fact = 1  # 用于做累乘的容器
    # 循环 递推
    for i in range(1, n + 1):
        fact *= i
        print(fact)
    return fact


print(factorial(5))

# 递归实现阶乘
"""
递归的核心:
1 自己调用自己  
2 递归------>(递推+回归)
3 递归只是一种思想   能用递推解决的都可以用递归实现  

在学数学时候
a**2 -1 = 0  求a的值    正负一   
(a+1)(a-1) = 0

a**4 -1 = 0 求a的值 
a的平方的平方   
b = a**2 
b**2 -1 = 0  --->b值算出来之后 -----> b = a**2 求a的值  (理解成回归)

"""


# 递归去实现阶乘
def asd(n):
    if n == 1:
        return 1  # 涉资了出口 我不在自己调用了
    else:
        return n * asd(n - 1)  # 在自己调用自己  函数体中
"""重复的去调用  算法 自己调用自己 """

result = asd(5)   # 在外面是不是只调用了一次
print(result)  # 120   asd(5)是120
"""
第一次调用     asd(5)       asd(5) =  5 * asd(4)
第二次调用     5 * asd(4)   asd(4) =  4 * asd(3)  
第三次调用     4 * asd(3)   asd(3) =  3 * asd(2)
第四次调用     3 * asd(2)   asd(2)  = 2 * asd(1)
第五次调用     2 * asd(1)   asd(1)  = 1
第六次调用     1  
总体的表达式   5 *  4 * 3 *  2 * 1

factorial(5)                        # 第 1 次调用使用 5
5 * factorial(4)                    # 第 2 次调用使用 4
5 * (4 * factorial(3))              # 第 3 次调用使用 3
5 * (4 * (3 * factorial(2)))        # 第 4 次调用使用 2
5 * (4 * (3 * (2 * factorial(1))))  # 第 5 次调用使用 1 
5 * (4 * (3 * (2 * 1)))             # 从第 5 次调用返回
5 * (4 * (3 * 2))                   # 从第 4 次调用返回
5 * (4 * 6)                         # 从第 3 次调用返回
5 * 24                              # 从第 2 次调用返回
120                                 # 从第 1 次调用返回
"""
